/**
 * 工具函数模块
 * 演示代码优化器可以检测和修复的常见 JavaScript 问题
 */

// 导入依赖
import axios from 'axios';
import { format } from 'date-fns';
import { v4 as uuidv4 } from 'uuid';
import { isEmpty, isNil, merge } from 'lodash';  // isEmpty 和 isNil 未使用

// 配置
const CONFIG = {
    apiUrl: 'https://api.example.com/v1',
    timeout: 30000,
    maxRetries: 3,
    retryDelay: 2000,
    defaultHeaders: {
        'Content-Type': 'application/json',
        'Accept': 'application/json',
    },
};

/**
 * 发送 API 请求
 * @param {string} url - 请求 URL
 * @param {Object} options - 请求选项
 * @param {string} options.method - 请求方法
 * @param {Object} options.params - URL 参数
 * @param {Object} options.data - 请求体数据
 * @param {Object} options.headers - 请求头
 * @param {number} options.timeout - 超时时间（毫秒）
 * @returns {Promise<Object>} 响应数据
 */
export async function apiRequest(url, options = {}) {
    const {
        method = 'GET',
        params = {},
        data = {},
        headers = {},
        timeout = CONFIG.timeout,
    } = options;

    // 合并默认头和自定义头
    const mergedHeaders = merge({}, CONFIG.defaultHeaders, headers);

    // 调试日志，应该在生产代码中删除
    console.log('API Request:', { url, method, params, data, headers: mergedHeaders });

    try {
        const response = await axios({
            url,
            method,
            params,
            data,
            headers: mergedHeaders,
            timeout,
        });

        // 这是一个非常长的行，超过了默认的最大长度限制，应该被拆分成多行以提高可读性和可维护性
        const responseData = response.data && typeof response.data === 'object' ? response.data : response.data ? JSON.parse(response.data) : {};

        // 调试日志，应该在生产代码中删除
        console.log('API Response:', responseData);

        return responseData;
    } catch (error) {
        // 调试日志，应该在生产代码中删除
        console.error('API Error:', error);

        // 重新抛出错误
        throw error;
    }
}

/**
 * 格式化日期
 * @param {Date|string|number} date - 日期对象、字符串或时间戳
 * @param {string} formatStr - 格式字符串
 * @returns {string} 格式化后的日期字符串
 */
export function formatDate(date, formatStr = 'yyyy-MM-dd HH:mm:ss') {
    // 转换日期
    const dateObj = typeof date === 'string' || typeof date === 'number'
        ? new Date(date)
        : date;

    // 格式化日期
    return format(dateObj, formatStr);
}

/**
 * 生成唯一 ID
 * @returns {string} 唯一 ID
 */
export function generateId() {
    return uuidv4();
}

/**
 * 解析 URL 参数
 * @param {string} url - URL 字符串
 * @returns {Object} 参数对象
 */
export function parseUrlParams(url) {
    // 提取查询字符串
    const queryString = url.split('?')[1] || '';

    // 解析参数
    const params = {};
    queryString.split('&').forEach(param => {
        if (!param) return;
        const [key, value] = param.split('=');
        params[decodeURIComponent(key)] = decodeURIComponent(value || '');
    });

    return params;
}

/**
 * 深度克隆对象
 * @param {Object} obj - 要克隆的对象
 * @returns {Object} 克隆后的对象
 */
export function deepClone(obj) {
    // TODO: 实现更高效的深度克隆算法
    return JSON.parse(JSON.stringify(obj));
}

/**
 * 防抖函数
 * @param {Function} func - 要防抖的函数
 * @param {number} wait - 等待时间（毫秒）
 * @returns {Function} 防抖后的函数
 */
export function debounce(func, wait) {
    let timeout;

    return function (...args) {
        const context = this;

        clearTimeout(timeout);

        timeout = setTimeout(() => {
            func.apply(context, args);
        }, wait);
    };
}

/**
 * 节流函数
 * @param {Function} func - 要节流的函数
 * @param {number} limit - 限制时间（毫秒）
 * @returns {Function} 节流后的函数
 */
export function throttle(func, limit) {
    let inThrottle;

    return function (...args) {
        const context = this;

        if (!inThrottle) {
            func.apply(context, args);
            inThrottle = true;
            setTimeout(() => {
                inThrottle = false;
            }, limit);
        }
    };
}

// 导出默认对象
export default {
    apiRequest,
    formatDate,
    generateId,
    parseUrlParams,
    deepClone,
    debounce,
    throttle,
};